package com.yuan.farmerwork.ynblog.utils;

import org.apache.commons.lang3.exception.ExceptionUtils;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import org.springframework.data.redis.connection.RedisZSetCommands;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.core.ZSetOperations;
import org.springframework.stereotype.Component;
import javax.annotation.Resource;
import java.util.Collection;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.concurrent.TimeUnit;

/**
 * Redis 操作工具类.
 *
 * @author 陈洪振
 */
@Component
public class RedisService {
  private Logger logger = LoggerFactory.getLogger(RedisService.class);
  @Resource
  private RedisTemplate<String, Object> redisTemplate;

  /**
   * 指定缓存失效时间.
   *
   * @param key  键
   * @param time 时间(秒)
   * @return
   */
  public boolean expire(String key, long time) {
    try {
      if (time > 0) {
        redisTemplate.expire(key, time, TimeUnit.SECONDS);
      }
      return true;
    } catch (Exception e) {
      logger.error(ExceptionUtils.getStackTrace(e));
      return false;
    }
  }

  /**
   * 根据key 获取过期时间.
   *
   * @param key 键 不能为null
   * @return 时间(秒) 返回0代表为永久有效
   */
  public long getExpire(String key) {
    return redisTemplate.getExpire(key, TimeUnit.SECONDS);
  }

  /**
   * 判断key是否存在.
   *
   * @param key 键
   * @return true 存在 false不存在
   */
  public boolean hasKey(String key) {
    try {
      return redisTemplate.hasKey(key);
    } catch (Exception e) {
      logger.error(ExceptionUtils.getStackTrace(e));
      return false;
    }
  }

  /**
   * 删除缓存.
   */
  public boolean del(String key) {
    if (hasKey(key)) {
      return redisTemplate.delete(key);
    }
    return false;
  }

  /**
   * 删除缓存.
   */
  @SuppressWarnings("unchecked")
  public void del(Collection<String> keys) {
    redisTemplate.delete(keys);
  }

  public Set<String> keys(String pattern) {
    return redisTemplate.keys(pattern);
  }

  /**
   * 普通缓存获取.
   *
   * @param key 键
   * @return 值
   */
  public Object get(String key) {
    try {
      return key == null ? null : redisTemplate.opsForValue().get(key);
    } catch (Exception e) {
      logger.error(ExceptionUtils.getStackTrace(e));
      return false;
    }
  }

  /**
   * 普通缓存放入.
   *
   * @param key   键
   * @param value 值
   * @return true成功 false失败
   */
  public boolean set(String key, Object value) {
    try {
      redisTemplate.opsForValue().set(key, value);
      return true;
    } catch (Exception e) {
      logger.error(ExceptionUtils.getStackTrace(e));
      return false;
    }
  }

  /**
   * 普通缓存放入并设置时间.
   *
   * @param key     键
   * @param value   值
   * @param seconds 时间(秒) time要大于0 如果time小于等于0 将设置无限期
   * @return true成功 false 失败
   */
  public boolean set(String key, Object value, long seconds) {
    try {
      if (seconds > 0) {
        redisTemplate.opsForValue().set(key, value, seconds, TimeUnit.SECONDS);
      } else {
        set(key, value);
      }
      return true;
    } catch (Exception e) {
      logger.error(ExceptionUtils.getStackTrace(e));
      return false;
    }
  }

  public boolean setnx(String key, Object value, long seconds) {
    try {
      if (!redisTemplate.opsForValue().setIfAbsent(key, value)) {
        return false;
      }
      if (seconds > 0) {
        redisTemplate.expire(key, seconds, TimeUnit.SECONDS);
      }
      return true;
    } catch (Exception e) {
      logger.error(ExceptionUtils.getStackTrace(e));
      return false;
    }
  }

  /**
   * 递增.
   *
   * @param key 键
   */
  public long incr(String key) {
    return redisTemplate.opsForValue().increment(key, 1);
  }

  /**
   * 递增.
   *
   * @param key   键
   * @param delta 要增加几(大于0)
   * @return
   */
  public long incr(String key, long delta) {
    if (delta < 0) {
      throw new RuntimeException("递增因子必须大于0");
    }
    return redisTemplate.opsForValue().increment(key, delta);
  }

  /**
   * 递减.
   *
   * @param key 键
   * @return
   */
  public long decr(String key) {
    return redisTemplate.opsForValue().increment(key, -1);
  }

  /**
   * 递减.
   *
   * @param key   键
   * @param delta 要减少几(小于0)
   * @return
   */
  public long decr(String key, long delta) {
    if (delta < 0) {
      throw new RuntimeException("递减因子必须大于0");
    }
    return redisTemplate.opsForValue().increment(key, -delta);
  }
  // ================================Map=================================

  /**
   * HashGet.
   *
   * @param key  键 不能为null
   * @param item 项 不能为null
   * @return 值
   */
  public Object hget(String key, String item) {
    return redisTemplate.opsForHash().get(key, item);
  }

  /**
   * 获取hashKey对应的所有键值.
   *
   * @param key 键
   * @return 对应的多个键值
   */
  public Map<Object, Object> hmget(String key) {
    return redisTemplate.opsForHash().entries(key);
  }

  /**
   * HashSet.
   *
   * @param key 键
   * @param map 对应多个键值
   * @return true 成功 false 失败
   */
  public boolean hmset(String key, Map<String, Object> map) {
    try {
      redisTemplate.opsForHash().putAll(key, map);
      return true;
    } catch (Exception e) {
      logger.error(ExceptionUtils.getStackTrace(e));
      return false;
    }
  }

  /**
   * HashSet 并设置时间.
   *
   * @param key  键
   * @param map  对应多个键值
   * @param time 时间(秒)
   * @return true成功 false失败
   */
  public boolean hmset(String key, Map<?, ?> map, long time) {
    try {
      redisTemplate.opsForHash().putAll(key, map);
      if (time > 0) {
        expire(key, time);
      }
      return true;
    } catch (Exception e) {
      logger.error(ExceptionUtils.getStackTrace(e));
      return false;
    }
  }

  /**
   * 向一张hash表中放入数据,如果不存在将创建.
   *
   * @param key   键
   * @param item  项
   * @param value 值
   * @return true 成功 false失败
   */
  public boolean hset(String key, String item, Object value) {
    try {
      redisTemplate.opsForHash().put(key, item, value);
      return true;
    } catch (Exception e) {
      logger.error(ExceptionUtils.getStackTrace(e));
      return false;
    }
  }

  /**
   * 向一张hash表中放入数据,如果不存在将创建.
   *
   * @param key   键
   * @param item  项
   * @param value 值
   * @param time  时间(秒) 注意:如果已存在的hash表有时间,这里将会替换原有的时间
   * @return true 成功 false失败
   */
  public boolean hset(String key, String item, Object value, long time) {
    try {
      redisTemplate.opsForHash().put(key, item, value);
      if (time > 0) {
        expire(key, time);
      }
      return true;
    } catch (Exception e) {
      logger.error(ExceptionUtils.getStackTrace(e));
      return false;
    }
  }


  /**
   * 向一张hash表中放入数据,如果不存在将创建.
   *
   * @param key   键
   * @param item  项
   * @param value 值
   * @return true 成功 false失败
   */
  public boolean hsetnx(String key, String item, Object value) {
    try {
      Boolean ret = redisTemplate.opsForHash().putIfAbsent(key, item, value);
      return ret != null && ret;
    } catch (Exception e) {
      logger.error(ExceptionUtils.getStackTrace(e));
      return false;
    }
  }


  /**
   * 向一张hash表中放入数据,如果不存在将创建.
   *
   * @param key   键
   * @param item  项
   * @param value 值
   * @param time  时间(秒) 注意:如果已存在的hash表有时间,这里将会替换原有的时间
   * @return true 成功 false失败
   */
  public boolean hsetnx(String key, String item, Object value, long time) {
    try {
      Boolean ret = redisTemplate.opsForHash().putIfAbsent(key, item, value);
      if (ret != null && ret && time > 0) {
        expire(key, time);
      }
      return ret != null && ret;
    } catch (Exception e) {
      logger.error(ExceptionUtils.getStackTrace(e));
      return false;
    }
  }

  /**
   * 删除hash表中的值.
   *
   * @param key  键 不能为null
   * @param item 项 可以使多个 不能为null
   */
  public void hdel(String key, Object... item) {
    redisTemplate.opsForHash().delete(key, item);
  }

  /**
   * 判断hash表中是否有该项的值.
   *
   * @param key  键 不能为null
   * @param item 项 不能为null
   * @return true 存在 false不存在
   */
  public boolean hHasKey(String key, String item) {
    return redisTemplate.opsForHash().hasKey(key, item);
  }

  /**
   * hash递增 如果不存在,就会创建一个 并把新增后的值返回.
   *
   * @param key  键
   * @param item 项
   * @param by   要增加几(大于0)
   * @return
   */
  public long hincr(String key, String item, long by) {
    return redisTemplate.opsForHash().increment(key, item, by);
  }

  public long hincr(String key, String item, long by, long time) {
    long d = redisTemplate.opsForHash().increment(key, item, by);
    if (time > 0) {
      redisTemplate.expire(key, time, TimeUnit.SECONDS);
    }
    return d;
  }

  /**
   * hash递减.
   *
   * @param key   键
   * @param item  项
   * @param delta 要减少的数
   * @return
   */
  public long hdecr(String key, String item, long delta) {
    return redisTemplate.opsForHash().increment(key, item, -delta);
  }
  // ============================set=============================

  /**
   * 根据key获取Set中的所有值.
   *
   * @param key 键
   * @return
   */
  public Set<Object> sGet(String key) {
    try {
      return redisTemplate.opsForSet().members(key);
    } catch (Exception e) {
      logger.error(ExceptionUtils.getStackTrace(e));
      return null;
    }
  }

  /**
   * 根据value从一个set中查询,是否存在.
   *
   * @param key   键
   * @param value 值
   * @return true 存在 false不存在
   */
  public boolean sHasKey(String key, Object value) {
    try {
      return redisTemplate.opsForSet().isMember(key, value);
    } catch (Exception e) {
      logger.error(ExceptionUtils.getStackTrace(e));
      return false;
    }
  }

  /**
   * 将数据放入set缓存.
   *
   * @param key    键
   * @param values 值 可以是多个
   * @return 成功个数
   */
  public long sSet(String key, Object... values) {
    try {
      return redisTemplate.opsForSet().add(key, values);
    } catch (Exception e) {
      logger.error(ExceptionUtils.getStackTrace(e));
      return 0;
    }
  }

  /**
   * 将set数据放入缓存.
   *
   * @param key    键
   * @param time   时间(秒)
   * @param values 值 可以是多个
   * @return 成功个数
   */
  public long sSetAndTime(String key, long time, Object... values) {
    try {
      Long count = redisTemplate.opsForSet().add(key, values);
      if (time > 0) {
        expire(key, time);
      }
      return count;
    } catch (Exception e) {
      logger.error(ExceptionUtils.getStackTrace(e));
      return 0;
    }
  }

  /**
   * 获取set缓存的长度.
   *
   * @param key 键
   * @return
   */
  public long sGetSetSize(String key) {
    try {
      return redisTemplate.opsForSet().size(key);
    } catch (Exception e) {
      logger.error(ExceptionUtils.getStackTrace(e));
      return 0;
    }
  }

  /**
   * 移除值为value的.
   *
   * @param key    键
   * @param values 值 可以是多个
   * @return 移除的个数
   */
  public long setRemove(String key, Object... values) {
    try {
      Long count = redisTemplate.opsForSet().remove(key, values);
      return count;
    } catch (Exception e) {
      logger.error(ExceptionUtils.getStackTrace(e));
      return 0;
    }
  }
  // ===============================list=================================

  /**
   * 获取list缓存的内容.
   *
   * @param key   键
   * @param start 开始
   * @param end   结束 0 到 -1代表所有值
   * @return
   */
  public List<Object> lGet(String key, long start, long end) {
    try {
      return redisTemplate.opsForList().range(key, start, end);
    } catch (Exception e) {
      logger.error(ExceptionUtils.getStackTrace(e));
      return null;
    }
  }

  /**
   * 获取list缓存的长度.
   *
   * @param key 键
   * @return
   */
  public long lGetListSize(String key) {
    try {
      return redisTemplate.opsForList().size(key);
    } catch (Exception e) {
      logger.error(ExceptionUtils.getStackTrace(e));
      return 0;
    }
  }

  /**
   * 通过索引 获取list中的值.
   *
   * @param key   键
   * @param index 索引 index>=0时， 0 表头，1 第二个元素，依次类推；index<0时，-1，表尾，-2倒数第二个元素，依次类推
   * @return
   */
  public Object lGetIndex(String key, long index) {
    try {
      return redisTemplate.opsForList().index(key, index);
    } catch (Exception e) {
      logger.error(ExceptionUtils.getStackTrace(e));
      return null;
    }
  }

  /**
   * 添加list.
   *
   * @param key  键
   * @param list list
   * @return
   */
  public long leftPushAll(String key, List<Object> list) {
    try {
      return redisTemplate.opsForList().leftPushAll(key, list);
    } catch (Exception e) {
      logger.error(ExceptionUtils.getStackTrace(e));
      return 0;
    }
  }


  /**
   * 将list放入缓存.
   *
   * @param key 键
   * @return
   */
  public Object leftPop(String key) {
    try {
      return redisTemplate.opsForList().leftPop(key);
    } catch (Exception e) {
      logger.error(ExceptionUtils.getStackTrace(e));
      return null;
    }
  }

  public Object leftPush(String key, Object obj) {
    try {
      return redisTemplate.opsForList().leftPush(key, obj);
    } catch (Exception e) {
      logger.error(ExceptionUtils.getStackTrace(e));
      return null;
    }
  }

  public void trim(String key, long start, long end) {
    redisTemplate.opsForList().trim(key, start, end);
  }

  /**
   * 向有序集合添加一个或多个成员，或者更新已存在成员的分数： ZADD key score1 member1 [score2 member2].
   */
  public Boolean zAdd(String key, Object value, double score) {
    try {
      return redisTemplate.opsForZSet().add(key, value, score);
    } catch (Exception e) {
      logger.error(ExceptionUtils.getStackTrace(e));
      return null;
    }
  }

  /**
   * 获取有序集合的成员数: ZCARD key.
   */
  public Long zCard(String key) {
    try {
      return redisTemplate.opsForZSet().zCard(key);
    } catch (Exception e) {
      logger.error(ExceptionUtils.getStackTrace(e));
      return null;
    }
  }

  /**
   * 计算在有序集合中指定区间分数的成员数: ZCOUNT key min max.
   */
  public Long zCount(String key, double min, double max) {
    try {
      return redisTemplate.opsForZSet().count(key, min, max);
    } catch (Exception e) {
      logger.error(ExceptionUtils.getStackTrace(e));
      return null;
    }
  }

  /**
   * 有序集合中对指定成员的分数加上增量 increment: ZINCRBY key increment member.
   */
  public Double zIncrby(String key, Object value, double delta) {
    try {
      return redisTemplate.opsForZSet().incrementScore(key, value, delta);
    } catch (Exception e) {
      logger.error(ExceptionUtils.getStackTrace(e));
      return null;
    }
  }

  /**
   * 计算给定的一个或多个有序集的交集并将结果集存储在新的有序集合 key 中: ZINTERSTORE destination numkeys key [key ...].
   */
  public Long zInterStore(String key, String otherKey, String destKey) {
    try {
      return redisTemplate.opsForZSet().intersectAndStore(key, otherKey, destKey);
    } catch (Exception e) {
      logger.error(ExceptionUtils.getStackTrace(e));
      return null;
    }
  }

  /**
   * 计算给定的一个或多个有序集的交集并将结果集存储在新的有序集合 key 中: ZINTERSTORE destination numkeys key [key ...].
   */
  public Long zInterStore(String key, Collection<String> otherKeys, String destKey) {
    try {
      return redisTemplate.opsForZSet().intersectAndStore(key, otherKeys, destKey);
    } catch (Exception e) {
      logger.error(ExceptionUtils.getStackTrace(e));
      return null;
    }
  }
  //在有序集合中计算指定字典区间内成员数量: ZLEXCOUNT key min max

  /**
   * 通过索引区间返回有序集合成指定区间内的成员: ZRANGE key start stop [WITHSCORES].
   */
  public Set zRange(String key, long start, long end) {
    try {
      return redisTemplate.opsForZSet().range(key, start, end);
    } catch (Exception e) {
      logger.error(ExceptionUtils.getStackTrace(e));
      return null;
    }
  }
  //在有序集合中计算指定字典区间内成员数量: ZLEXCOUNT key min max.

  /**
   * 通过索引区间返回有序集合成指定区间内的成员(逆序): ZRANGE key start stop [WITHSCORES].
   */
  public Set zRevRange(String key, long start, long end) {
    try {
      return redisTemplate.opsForZSet().reverseRange(key, start, end);
    } catch (Exception e) {
      logger.error(ExceptionUtils.getStackTrace(e));
      return null;
    }
  }

  /**
   * 通过字典区间返回有序集合的成员: ZRANGEBYLEX key min max [LIMIT offset count].
   */
  public Set zRangeByLex(String key, Object min, boolean containsMin, Object max, boolean containsMax) {
    try {
      RedisZSetCommands.Range range = RedisZSetCommands.Range.range();
      if (containsMin) {
        range.gte(min);
      } else {
        range.gt(min);
      }
      if (containsMax) {
        range.lte(max);
      } else {
        range.lt(max);
      }
      return redisTemplate.opsForZSet().rangeByLex(key, range);
    } catch (Exception e) {
      logger.error(ExceptionUtils.getStackTrace(e));
      return null;
    }
  }

  /**
   * 通过字典区间返回有序集合的成员: ZRANGEBYLEX key min max [LIMIT offset count].
   */
  public Set zRangeByLex(String key, Object min, boolean containsMin,
                         Object max, boolean containsMax, int offset, int count) {
    try {
      RedisZSetCommands.Range range = RedisZSetCommands.Range.range();
      if (containsMin) {
        range.gte(min);
      } else {
        range.gt(min);
      }
      if (containsMax) {
        range.lte(max);
      } else {
        range.lt(max);
      }
      RedisZSetCommands.Limit limit = RedisZSetCommands.Limit.limit();
      limit.offset(offset);
      limit.count(count);
      return redisTemplate.opsForZSet().rangeByLex(key, range, limit);
    } catch (Exception e) {
      logger.error(ExceptionUtils.getStackTrace(e));
      return null;
    }
  }

  /**
   * 通过分数返回有序集合指定区间内的成员: ZRANGEBYSCORE key min max [WITHSCORES] [LIMIT].
   */
  public Set zRangeByScore(String key, double min, double max) {
    try {
      return redisTemplate.opsForZSet().rangeByScore(key, min, max);
    } catch (Exception e) {
      logger.error(ExceptionUtils.getStackTrace(e));
      return null;
    }
  }

  /**
   * 通过分数返回有序集合指定区间内的成员: ZRANGEBYSCORE key min max [WITHSCORES] [LIMIT].
   */
  public Set zRangeByScore(String key, double min, double max, int offset, int count) {
    try {
      return redisTemplate.opsForZSet().rangeByScore(key, min, max, offset, count);
    } catch (Exception e) {
      logger.error(ExceptionUtils.getStackTrace(e));
      return null;
    }
  }

  /**
   * 返回有序集key中成员member的排名。其中有序集成员按score值递增<b>(从小到大)</b>顺序排列。ZRANK key member.
   */
  public Long zRank(String key, Object value) {
    try {
      return redisTemplate.opsForZSet().rank(key, value);
    } catch (Exception e) {
      logger.error(ExceptionUtils.getStackTrace(e));
      return null;
    }
  }

  /**
   * 返回有序集key中成员member的排名。其中有序集成员按score值递减(从大到小)排序。ZREVRANK key member.
   */
  public Long zRevRank(String key, Object value) {
    try {
      return redisTemplate.opsForZSet().reverseRank(key, value);
    } catch (Exception e) {
      logger.error(ExceptionUtils.getStackTrace(e));
      return null;
    }
  }

  /**
   * 返回有序集中指定区间内的成员，通过索引，分数从高到底   ZREVRANGE key start stop [WITHSCORES].
   */
  public Set<ZSetOperations.TypedTuple<Object>> reverseRangeWithScores(String key, int start, int end) {
    try {
      return redisTemplate.opsForZSet().reverseRangeWithScores(key, start, end);
    } catch (Exception e) {
      logger.error(ExceptionUtils.getStackTrace(e));
      return null;
    }
  }

  /**
   * 移除有序集合中的一个或多个成员: ZREM key member [member ...].
   */
  public Long zRemove(String key, Object... values) {
    try {
      return redisTemplate.opsForZSet().remove(key, values);
    } catch (Exception e) {
      logger.error(ExceptionUtils.getStackTrace(e));
      return null;
    }
  }
  //移除有序集合中给定的字典区间的所有成员: ZREMRANGEBYLEX key min max
  //移除有序集合中给定的排名区间的所有成员：ZREMRANGEBYRANK key start stop
  //移除有序集合中给定的分数区间的所有成员：ZREMRANGEBYSCORE key min max
  //返回有序集中指定区间内的成员，通过索引，分数从高到底：ZREVRANGE key start stop [WITHSCORES]
  //返回有序集中指定分数区间内的成员，分数从高到低排序：ZREVRANGEBYSCORE key max min [WITHSCORES]
  //返回有序集合中指定成员的排名，有序集成员按分数值递减(从大到小)排序：ZREVRANK key member

  /**
   * 返回有序集中，成员的分数值:ZSCORE key member.
   */
  public Double zScore(String key, Object value) {
    try {
      return redisTemplate.opsForZSet().score(key, value);
    } catch (Exception e) {
      logger.error(ExceptionUtils.getStackTrace(e));
      return null;
    }
  }
  //计算给定的一个或多个有序集的并集，并存储在新的 key 中:ZUNIONSTORE destination numkeys key [key ...]
  //迭代有序集合中的元素（包括元素成员和元素分值）:ZSCAN key cursor [MATCH pattern] [COUNT count]

  /**
   * 将list放入缓存.
   *
   * @param key   键
   * @param value 值
   * @return
   */
  public boolean rightPush(String key, Object value) {
    try {
      redisTemplate.opsForList().rightPush(key, value);
      return true;
    } catch (Exception e) {
      logger.error(ExceptionUtils.getStackTrace(e));
      return false;
    }
  }


  /**
   * 将list放入缓存.
   *
   * @param key   键
   * @param value 值
   * @param time  时间(秒)
   * @return
   */
  public boolean rightPush(String key, Object value, long time) {
    try {
      redisTemplate.opsForList().rightPush(key, value);
      if (time > 0) {
        expire(key, time);
      }
      return true;
    } catch (Exception e) {
      logger.error(ExceptionUtils.getStackTrace(e));
      return false;
    }
  }


  /**
   * 将list放入缓存.
   *
   * @param key   键
   * @param value 值
   * @return
   */
  public boolean rightPushAll(String key, List<Object> value) {
    try {
      redisTemplate.opsForList().rightPushAll(key, value);
      return true;
    } catch (Exception e) {
      logger.error(ExceptionUtils.getStackTrace(e));
      return false;
    }
  }

  /**
   * 将list放入缓存.
   *
   * @param key   键
   * @param value 值
   * @return
   */
  public boolean lSet(String key, Object value) {
    try {
      redisTemplate.opsForList().rightPush(key, value);
      return true;
    } catch (Exception e) {
      logger.error(ExceptionUtils.getStackTrace(e));
      return false;
    }
  }

  /**
   * 将list放入缓存.
   *
   * @param key   键
   * @param value 值
   * @param time  时间(秒)
   * @return
   */
  public boolean lSet(String key, Object value, long time) {
    try {
      redisTemplate.opsForList().rightPush(key, value);
      if (time > 0) {
        expire(key, time);
      }
      return true;
    } catch (Exception e) {
      logger.error(ExceptionUtils.getStackTrace(e));
      return false;
    }
  }

  /**
   * 将list放入缓存.
   *
   * @param key   键
   * @param value 值
   * @return
   */
  public boolean lSet(String key, List<Object> value) {
    try {
      redisTemplate.opsForList().rightPushAll(key, value);
      return true;
    } catch (Exception e) {
      logger.error(ExceptionUtils.getStackTrace(e));
      return false;
    }
  }

  /**
   * 将list放入缓存.
   *
   * @param key   键
   * @param value 值
   * @param time  时间(秒)
   * @return
   */
  public boolean lSet(String key, List<Object> value, long time) {
    try {
      redisTemplate.opsForList().rightPushAll(key, value);
      if (time > 0) {
        expire(key, time);
      }
      return true;
    } catch (Exception e) {
      logger.error(ExceptionUtils.getStackTrace(e));
      return false;
    }
  }

  /**
   * 根据索引修改list中的某条数据.
   *
   * @param key   键
   * @param index 索引
   * @param value 值
   * @return
   */
  public boolean lUpdateIndex(String key, long index, Object value) {
    try {
      redisTemplate.opsForList().set(key, index, value);
      return true;
    } catch (Exception e) {
      logger.error(ExceptionUtils.getStackTrace(e));
      return false;
    }
  }

  /**
   * 移除N个值为value.
   *
   * @param key   键
   * @param count 移除多少个
   * @param value 值
   * @return 移除的个数
   */
  public long lRemove(String key, long count, Object value) {
    try {
      Long remove = redisTemplate.opsForList().remove(key, count, value);
      return remove;
    } catch (Exception e) {
      logger.error(ExceptionUtils.getStackTrace(e));
      return 0;
    }
  }

  /**
   * 通过key获取所有的field和value.
   *
   * @param key 键
   * @return Map
   */
  public Map<Object, Object> hgetall(String key) {
    try {
      return redisTemplate.opsForHash().entries(key);
    } catch (Exception e) {
      logger.error(ExceptionUtils.getStackTrace(e));
      return null;
    }
  }
}
